package net.sansi.v3correctserver.util;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * Created by Fang
 * create time : 2025/2/28
 * IDE : IntelliJ IDEA
 * <p>
 * 简易缓存实现
 * 该缓存没有自动清空功能
 * 需要手动清空
 */

public class LocalCache<T> {

    // 缓存
    private final Map<Object, T> cache = new ConcurrentHashMap<>();

    /**
     * 移除缓存
     *
     * @param key 缓存键
     */
    public void remove(Object key) {
        cache.remove(key);
    }

    /**
     * 添加缓存
     *
     * @param key   缓存键
     * @param value 缓存值
     */
    public void put(Object key, T value) {
        cache.put(key, value);
    }

    /**
     * 获取缓存
     *
     * @param key 缓存键
     * @return 缓存值
     */
    public T get(Object key) {
        return cache.get(key);
    }

    /**
     * 获取缓存
     * 带默认值
     *
     * @param key          缓存键
     * @param defaultValue 默认值
     * @return 缓存值
     */
    public T get(Object key, T defaultValue) {
        return cache.getOrDefault(key, defaultValue);
    }

    public interface GenValue<T> {
        T get();
    }

    /**
     * 获取缓存
     * 带value生成函数
     *
     * @param key      缓存键
     * @param genValue value生成函数
     * @return 缓存值
     */
    public T get(Object key, GenValue<T> genValue) {
        T value = cache.get(key);
        if (value == null) {
            value = genValue.get();
            cache.put(key, value);
        }
        return value;
    }

    /**
     * 无视缓存中的内容，直接调用 genValue 生成新的 value
     * 新value会被放入缓存中
     *
     * @param key         缓存键
     * @param genValue    value生成函数
     * @param ignoreCache 是否无视缓存
     * @return 缓存值
     */
    public T get(Object key, GenValue<T> genValue, boolean ignoreCache) {
        if (ignoreCache) {
            T value = genValue.get();
            cache.put(key, value);
            return value;
        }
        return get(key, genValue);
    }


    /**
     * 清空缓存
     */
    public void clear() {
        cache.clear();
    }


}
